package chatModel;

import java.io.File;
import java.net.InetAddress;
import java.util.Observable;

import messages.MessageCreationException;
import messages.MessagesFactory;

/**
 * Classe qui permet d'envoyer des notifications au NI
 * 
 */
public class ModeleMsgToNI extends Observable {

	private Utilisateur utilisateurLocal;
	/*private String userName;
	private InetAddress myIp;*/
	
	private int choix;
	private byte[] msgToSend;
	private File file;
	private String nameFileProposed;
	private UtilisateurDistant userDistant;
	private InetAddress adresseIPUtilisateurDistant;
	private long lengthFile;

        /**
         * Constructeur
         * @param utilisateurLocal : Utilisateur local
         */
	public ModeleMsgToNI(Utilisateur utilisateurLocal) {
		super();
		this.utilisateurLocal=utilisateurLocal;
	}

        /**
         * Donne l'utilisateur local
         * @return Utilisateur : Utilisateur local
         */
	public Utilisateur getUtilisateurLocal() {
		return utilisateurLocal;
	}
        
        /**
         * Change l'utilisateur local
         * @param utilisateurLocal  : nouvel utilisateur local
         */
	public void setUtilisateurLocal(Utilisateur utilisateurLocal) {
		this.utilisateurLocal = utilisateurLocal;
	}
	
/*	public void setUserName(String userName) {
		this.userName = userName;
	}

	public InetAddress getMyIp() {
		return myIp;
	}

	public void setMyIp(InetAddress myIp) {
		this.myIp = myIp;
	}
*/
        /**
         * Donne la valeur de la notification
         * @see chatModel.Choix Choix
         * @return Entier donnant la vleur de la notification
         */
	public int getChoix() {
		return choix;
	}

        /**
         * Change la valeur de la notification
         * @see chatModel.Choix Choix
         * @param choix : Entier indiquant la nouvelle valeur de la notification
         */
	public void setChoix(int choix) {
		this.choix = choix;
	}

        /**
         * Donne le message que le NI doit envoyer
         * @return Message que le NI doit envoyer
         */
	public byte[] getMsgToSend() {
		return msgToSend;
	}
        
        /**
         * Sauvegarde le message que le NI devra envoyer
         * @param msgToSend Message que le NI devra envoyer
         */
	public void setMsgToSend(byte[] msgToSend) {
		this.msgToSend = msgToSend;
	}

        /**
         * Donne la taille du fichier qui va être transféré
         * @return 
         */
	public long getLengthFile() {
		return lengthFile;
	}

        /**
         * Donne le fichier ou futur fichier qui sera transféré
         * @return 
         */
	public File getFile() {
		return file;
	}

        /**
         * Change le fichier ou futur fichier à transférer
         * @param file 
         */
	public void setFile(File file) {
		this.file = file;
	}

        /**
         * Donne le nom du fichier proposé
         * @return Nom du fichier proposé
         */
	public String getNameFileProposed() {
		return nameFileProposed;
	}

        /**
         * Change le nom du fichier proposé
         * @param nameFileProposed : Nom du fichier proposé
         */
	public void setNameFileProposed(String nameFileProposed) {
		this.nameFileProposed = nameFileProposed;
	}

        /**
         * Donne l'utilisateur distant concerné dans cette notification
         * @return L'utilisateur distant
         */
	public UtilisateurDistant getUserDistant() {
		return userDistant;
	}

        /**
         * Change l'utilisateur distant concerné
         * @param userDistant Utilisateur distant concerné
         */
	public void setUserDistant(UtilisateurDistant userDistant) {
		this.userDistant = userDistant;
	}

        /**
         * Donne l'adresse IP de l'utilisateur distant
         * @return Adresse IP de l'utilisateur distant
         */
	public InetAddress getAdresseIPUtilisateurDistant() {
		return adresseIPUtilisateurDistant;
	}

        /**
         * Change l'adresse IP de l'utilisateur distant
         * @param adresseIPUtilisateurDistant Adresse IP de l'utilisateur distant
         */
	public void setAdresseIPUtilisateurDistant(
			InetAddress adresseIPUtilisateurDistant) {
		this.adresseIPUtilisateurDistant = adresseIPUtilisateurDistant;
	}
	
        /**
         * Notifie que l'utilisateur passe à l'état connecté
         * @see chatModel.Choix#connexionOk
         * @see chatNI.ChatNI#update(java.util.Observable, java.lang.Object) update
         */
	public void connect(){
		this.choix=Choix.connexionOk;
		System.out.println("model ni connecté");
		this.setChanged();
		this.notifyObservers(this);
	}
	
        /**
         * Notifie que l'utilisateur passe à l'état déconnecté
         */
	public void disconnect(){
		this.choix=Choix.deconnexionOk;
		this.setChanged();
		this.notifyObservers(this);
	}
	
        /**
         * Notifie qu'un message doit être envoyé
         * @see chatNI.ChatNI#update(java.util.Observable, java.lang.Object) update
         * @see chatModel.Choix#sendMsgOneUser sendMsgOneUser
         * @see chatModel.Choix#sendMsgAllUser sendMsgAllUser
         * @param user Utilisateur distant recepteur du message
         * @param msg Message à envoyer
         */
	public void sendMsg(UtilisateurDistant user, String msg){
		this.userDistant=user;
		if(user.getUserName().compareTo("All Users")==0){
			this.choix = Choix.sendMsgAllUser;
		}else
			this.choix=Choix.sendMsgOneUser;
		try {
			this.msgToSend = MessagesFactory.getChatMessage(this.utilisateurLocal.getUserName(), msg);
		} catch (MessageCreationException e) {
			System.out.println("Probleme création message dans sendMsgToNI");
			e.printStackTrace();
		}
		this.setChanged();
		super.notifyObservers(this);
	}

        /**
         * Notifie qu'une demande de fichier doit être envoyé
         * @see chatModel.Choix#sendFileNotifAllUser sendFileNotifAllUser
         * @see chatModel.Choix#sendFileNotifOneUser sendFileNotifOneUser
         * @param user Utilisateur distant
         * @param file Fichier concerné
         * @param lengthFile Longueur du fichier
         */
	public void sendDemandeFile(UtilisateurDistant user, File file, long lengthFile){
		this.userDistant=user;
		this.file = file;
		this.lengthFile=lengthFile;
		if(user.getUserName().compareTo("All Users")==0){
			this.choix = Choix.sendFileNotifAllUser;
		}else
			this.choix=Choix.sendFileNotifOneUser;
		try {
			this.msgToSend = MessagesFactory.getFileNotif(this.utilisateurLocal.getUserName(), file.getName(), true, false, this.lengthFile);
		} catch (MessageCreationException e) {
			System.out.println("Probleme création message dans sendMsgToNI");
			e.printStackTrace();
		}
		this.setChanged();
		super.notifyObservers(this);
	}

        /**
         * Change la taille du fichier reçu
         * @param lengthFile Taille du fichier reçu
         */
	public void setTailleFileRecu(long lengthFile){
		this.lengthFile=lengthFile;
	}
	
        /**
         * Notification indiquant que l'utilisateur accepte le fichier
         * @see chatModel.Choix#confAcceptFileOk confAcceptFileOk
         * @see chatNI.ChatNI#update(java.util.Observable, java.lang.Object)  update
         * @param user Utilisateur distant qui a proposé le fichier
         * @param file Future fichier qui sera le fichier reçu
         */
	public void acceptFile(UtilisateurDistant user, File file){
		this.userDistant=user;
		this.choix=Choix.confAcceptFileOk;
		this.file=file;
		try {
			this.msgToSend = MessagesFactory.getFileNotif(this.utilisateurLocal.getUserName(), file.getName(), false, true, this.lengthFile);
		} catch (MessageCreationException e) {
			System.out.println("Probleme création message dans sendMsgToNI");
			e.printStackTrace();
		}
		this.setChanged();
		super.notifyObservers(this);
	}

        /**
         * Notification indiquant que l'utilisateur refuse le fichier
         * @see chatNI.ChatNI#update(java.util.Observable, java.lang.Object) update
         * @see chatModel.Choix#confAcceptFileNoOk confAcceptFileNoOk
         * @param user Utilisateur distant qui a proposé le fichier
         * @param nameFile Nom du fichier
         */
	public void refuseFile(UtilisateurDistant user, String nameFile){
		this.userDistant=user;
		this.choix=Choix.confAcceptFileNoOk;
		try {
			this.msgToSend = MessagesFactory.getFileNotif(this.utilisateurLocal.getUserName(), nameFile, false, false, this.lengthFile);
		} catch (MessageCreationException e) {
			System.out.println("Probleme création message dans sendMsgToNI");
			e.printStackTrace();
		}
		this.setChanged();
		super.notifyObservers(this);
	}
	
        /**
         * Notifie que l'on doit envoyer un Hello Négatif
         * @see chatModel.Choix#rcvNewHello rcvNewHello
         * @see chatNI.ChatNI#update(java.util.Observable, java.lang.Object) update
         * @param destinataire Utilisateur distant
         * @throws MessageCreationException Erreur lors de la construction du Hello négatif
         */
	public void notifyChatNISendNegHello(UtilisateurDistant destinataire) throws MessageCreationException {
		System.out.println("Construction d'un Hello Negatif");
		this.choix = Choix.rcvNewHello;
		this.userDistant= destinataire;
		this.msgToSend = MessagesFactory.getHello(this.utilisateurLocal.getUserName(), false);
		this.setChanged();
		this.notifyObservers(this);
		
	}

        /**
         * Notifie le NI pour envoyer le fichier 
         * @see chatNI.ChatNI#update(java.util.Observable, java.lang.Object) update
         * @see chatModel.Choix#rcvAcceptedFile rcvAcceptedFile
         * @param user utilisateur distant qui va recevoir le fichier
         * @param nameFile Nom du fichier à eenvoyer
         */
	public void notifyNISendFile(UtilisateurDistant user, String nameFile){
		this.userDistant=user;
		this.choix=Choix.rcvAcceptedFile;
		System.out.println("le NI envoie le fichier");
		this.setChanged();
		super.notifyObservers(this);
	}
	
        /**
         * Notifie le NI qu'il doit fermer la connexion au réseau
         * @see chatModel.Choix#quitChat quitChat
         * @see chatNI.ChatNI#update(java.util.Observable, java.lang.Object) update
         */
	public void close(){
		System.out.println("envoie quitte");
		this.choix=Choix.quitChat;
		this.setChanged();
		super.notifyObservers(this);
	}
}
